/**
 * 认证中间件
 * 包含登录验证、角色验证和权限验证功能
 */

class UnifiedAuthMiddleware {
    
    /**
     * 执行权限验证的核心逻辑
     * @param {Object} context 上下文对象
     * @param {Object} options 验证选项
     * @param {boolean} options.requireLogin 是否要求登录
     * @param {string|Array} options.requireRole 要求的角色
     * @param {string|Array} options.requirePermission 要求的权限
     * @param {boolean} options.requireAdmin 是否要求管理员角色
     * @returns {Object|null} 验证失败返回错误对象，成功返回null
     */
    static async validatePermissions(context, options = {}) {
        const { requireLogin = false, requireRole = null, requirePermission = null, requireAdmin = false } = options;
        
        // 检查登录状态
        if (requireLogin || requireRole || requirePermission) {
            if (!context.uniIdToken) {
                return {
                    code: 401,
                    message: '请先登录',
                    data: null
                };
            }
            
            // 获取用户信息
            try {
                const uniID = require('uni-id');
                const userInfo = await uniID.checkToken(context.uniIdToken);
                
                if (userInfo.code !== 0) {
                    return {
                        code: 401,
                        message: '登录已过期，请重新登录',
                        data: null
                    };
                }
                
                // 将用户信息注入到上下文中
                context.userInfo = userInfo.userInfo;
                
                // 检查角色权限
                if (requireRole) {
                    const hasRole = UnifiedAuthMiddleware.hasRole(userInfo.userInfo, requireRole);
                    if (!hasRole) {
                        return {
                            code: 403,
                            message: '权限不足，需要特定角色',
                            data: null
                        };
                    }
                }
                
                // 检查具体权限
                if (requirePermission) {
                    const hasPermission = UnifiedAuthMiddleware.hasPermission(userInfo.userInfo, requirePermission);
                    if (!hasPermission) {
                        return {
                            code: 403,
                            message: '权限不足',
                            data: null
                        };
                    }
                }
                
            } catch (error) {
                return {
                    code: 500,
                    message: '权限验证失败',
                    data: null
                };
            }
        }
        
        // 检查管理员角色
        if (requireAdmin) {
            if (!UnifiedAuthMiddleware.hasRole(context.userInfo, 'admin')) {
                return {
                    code: 403,
                    message: '权限不足，需要管理员角色',
                    data: null
                };
            }
        }
        
        return null; // 验证通过
    }
    
    /**
     * 创建认证中间件
     * @param {Object} options 配置选项
     * @param {boolean} options.requireLogin 是否要求登录
     * @param {string|Array} options.requireRole 要求的角色
     * @param {string|Array} options.requirePermission 要求的权限
     * @param {boolean} options.requireAdmin 是否要求管理员角色
     * @returns {Function} 认证中间件函数
     */
    static createAuthMiddleware(options = {}) {
        return function authMiddleware(handler) {
            return async function(...args) {
                const context = this;
                
                // 使用统一的权限验证逻辑
                const validationResult = await UnifiedAuthMiddleware.validatePermissions(context, options);
                if (validationResult) {
                    return validationResult;
                }
                
                // 执行原始处理函数
                return handler.apply(context, args);
            };
        };
    }
    
    /**
     * 检查用户是否拥有指定角色
     * @param {Object} userInfo 用户信息
     * @param {string|Array} roles 要求的角色
     * @returns {boolean} 是否拥有角色
     */
    static hasRole(userInfo, roles) {
        if (!userInfo || !userInfo.role) return false;
        
        const userRoles = Array.isArray(userInfo.role) ? userInfo.role : [userInfo.role];
        const requiredRoles = Array.isArray(roles) ? roles : [roles];
        
        return requiredRoles.some(role => userRoles.includes(role));
    }
    
    /**
     * 检查用户是否拥有指定权限
     * @param {Object} userInfo 用户信息
     * @param {string|Array} permissions 要求的权限
     * @returns {boolean} 是否拥有权限
     */
    static hasPermission(userInfo, permissions) {
        if (!userInfo || !userInfo.permission) return false;
        
        const userPermissions = Array.isArray(userInfo.permission) ? userInfo.permission : [userInfo.permission];
        const requiredPermissions = Array.isArray(permissions) ? permissions : [permissions];
        
        return requiredPermissions.some(permission => userPermissions.includes(permission));
    }

    
    /**
     * 快捷方法：要求登录
     * @returns {Function} 登录中间件
     */
    static requireLogin() {
        return UnifiedAuthMiddleware.createAuthMiddleware({ requireLogin: true });
    }
    
    /**
     * 快捷方法：要求管理员角色
     * @returns {Function} 管理员中间件
     */
    static requireAdmin() {
        return UnifiedAuthMiddleware.createAuthMiddleware({ requireAdmin: true });
    }
}

module.exports = { UnifiedAuthMiddleware };